import { AI_CONFIG } from './aiConfig';

/**
 * AI 服务类 - 处理与AI服务的通信
 */
export class AIService {
  /**
   * 使用fetch API处理流式请求（备选方案）
   * @param messages 消息数组
   * @param onPartialResponse 流式响应的回调函数
   * @returns 完整响应文本
   */
  private static async streamWithFetch(
    messages: Array<{role: string, content: string}>,
    onPartialResponse?: (partialResponse: string) => void
  ): Promise<string> {
    try {
      const response = await fetch(AI_CONFIG.apiEndpoint, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
          'Authorization': `Bearer ${AI_CONFIG.apiKey}`
        },
        body: JSON.stringify({
          model: AI_CONFIG.model,
          messages,
          max_tokens: AI_CONFIG.maxTokens,
          temperature: AI_CONFIG.temperature,
          stream: true, // 启用流式响应
        }),
      });

      if (!response.ok || !response.body) {
        throw new Error(`HTTP error! Status: ${response.status}`);
      }

      const reader = response.body.getReader();
      const decoder = new TextDecoder('utf-8');
      let fullResponse = '';
      let buffer = '';

      // 用于处理SSE格式的数据
      const processChunk = (chunk: string) => {
        const lines = chunk.split('\n');
        let result = '';

        for (const line of lines) {
          if (line.startsWith('data: ')) {
            const data = line.slice(5);
            if (data === '[DONE]') {
              return result;
            }

            // 特殊处理 \n 情况
            if (data === '\\n' || data === '\n') {
              result += '\n'; // 添加真正的换行符
              continue;
            }
            
            try {
              try {
                const parsed = JSON.parse(data);
                const content = parsed.choices[0]?.delta?.content || '';
                // 处理内容中可能存在的 \n 文本
                result += content.replace(/\\n/g, '\n');
              } catch (jsonError) {
                // 如果解析失败，直接使用数据，但要处理可能的 \n
                if (data && data.trim()) {
                  result += data.replace(/\\n/g, '\n');
                }
              }
            } catch (e) {
              console.error('解析SSE数据失败:', e);
            }
          }
        }

        return result;
      };

      while (true) {
        const { done, value } = await reader.read();
        if (done) break;

        // 解码二进制数据
        const chunk = decoder.decode(value, { stream: true });
        buffer += chunk;

        // 处理完整的SSE消息
        const content = processChunk(buffer);
        if (content) {
          fullResponse += content;
          if (onPartialResponse) {
            onPartialResponse(fullResponse);
          }
          buffer = ''; // 清空缓冲区
        }
      }

      // 清理可能存在的 [DONE] 标记
      const cleanedResponse = fullResponse.replace(/\[DONE\]/g, '');
      return cleanedResponse;
    } catch (error: any) {
      console.error('Fetch流式请求错误:', error);
      throw new Error(error.message || '流式请求失败');
    }
  }

  /**
   * 根据指令修改 HTML 代码
   * @param htmlCode 原始HTML代码
   * @param prompt 用户指令
   * @param onPartialResponse 流式响应的回调函数
   * @returns 修改后的HTML代码
   */
  static async modifyHtml(
    htmlCode: string, 
    prompt: string, 
    onPartialResponse?: (partialResponse: string) => void
  ): Promise<string> {
    try {
      const fullPrompt = `
我有以下HTML代码，请根据我的指令修改它：

\`\`\`html
${htmlCode}
\`\`\`

我的指令是: ${prompt}

请直接返回完整修改后的HTML代码，不需要任何解释。只返回代码本身，不要使用markdown格式或代码块。
`;

      const messages = [
        { role: 'system', content: '你是一个专业的前端开发助手，擅长修改HTML代码。' },
        { role: 'user', content: fullPrompt }
      ];

      // 如果没有提供回调函数，创建一个空函数
      const callback = onPartialResponse || (() => {});
      
      // 开始流式响应处理
      if (onPartialResponse) {
        onPartialResponse('正在处理您的请求...');
      }
      
      try {
        // 使用fetch API实现流式响应
        const result = await this.streamWithFetch(messages, (partial) => {
          // 移除开头的"正在处理您的请求..."
          if (partial.startsWith('正在处理您的请求...')) {
            partial = partial.substring('正在处理您的请求...'.length);
          }
          callback(partial);
        });
        // 清理结果中可能存在的 [DONE] 标记
        return result.replace(/\[DONE\]/g, '');
      } catch (error) {
        console.error('流式响应错误:', error);
        throw error;
      }
    } catch (error: any) {
      console.error('AI API 错误:', error);
      throw new Error(error.message || 'API请求失败');
    }
  }

  /**
   * 根据指令修改 HTML 代码片段
   * @param snippet 选中的HTML代码片段
   * @param prompt 用户指令
   * @param onPartialResponse 流式响应的回调函数
   * @returns 修改后的HTML代码片段
   */
  static async modifyHtmlSnippet(
    snippet: string, 
    prompt: string, 
    onPartialResponse?: (partialResponse: string) => void
  ): Promise<string> {
    try {
      const fullPrompt = `
我有一段HTML代码片段，请根据我的指令修改它。

我的指令是: "${prompt}"

HTML代码片段如下:
\`\`\`html
${snippet}
\`\`\`

请直接返回修改后的HTML代码片段，不需要任何解释或上下文，只返回代码本身，不要使用markdown格式或代码块。
`;

      const messages = [
        { role: 'system', content: '你是一个专业的前端开发助手，擅长修改HTML代码片段。' },
        { role: 'user', content: fullPrompt }
      ];

      // 如果没有提供回调函数，创建一个空函数
      const callback = onPartialResponse || (() => {});
      
      // 开始流式响应处理
      if (onPartialResponse) {
        onPartialResponse('正在处理您的请求...');
      }
      
      try {
        // 使用fetch API实现流式响应
        const result = await this.streamWithFetch(messages, (partial) => {
          // 移除开头的"正在处理您的请求..."
          if (partial.startsWith('正在处理您的请求...')) {
            partial = partial.substring('正在处理您的请求...'.length);
          }
          callback(partial);
        });
        // 清理结果中可能存在的 [DONE] 标记
        return result.replace(/\[DONE\]/g, '');
      } catch (error) {
        console.error('流式响应错误:', error);
        throw error;
      }
    } catch (error: any) {
      console.error('AI API 错误:', error);
      throw new Error(error.message || 'API请求失败');
    }
  }
} 